﻿using Idlesoft.Utils;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using System;
using System.Reflection;
using System.IO;
using System.ComponentModel;
using System.Linq.Expressions;
using System.Collections.Generic;
using System.Security;
using System.Diagnostics;

namespace UtilsTests
{
    
    
    /// <summary>
    ///This is a test class for CommonTest and is intended
    ///to contain all CommonTest Unit Tests
    ///</summary>
	[TestClass()]
	public class CommonTest
	{


		private TestContext testContextInstance;

		/// <summary>
		///Gets or sets the test context which provides
		///information about and functionality for the current test run.
		///</summary>
		public TestContext TestContext
		{
			get
			{
				return testContextInstance;
			}
			set
			{
				testContextInstance = value;
			}
		}

		#region Additional test attributes
		// 
		//You can use the following additional attributes as you write your tests:
		//
		//Use ClassInitialize to run code before running the first test in the class
		//[ClassInitialize()]
		//public static void MyClassInitialize(TestContext testContext)
		//{
		//}
		//
		//Use ClassCleanup to run code after all tests in a class have run
		//[ClassCleanup()]
		//public static void MyClassCleanup()
		//{
		//}
		//
		//Use TestInitialize to run code before running each test
		//[TestInitialize()]
		//public void MyTestInitialize()
		//{
		//}
		//
		//Use TestCleanup to run code after each test has run
		//[TestCleanup()]
		//public void MyTestCleanup()
		//{
		//}
		//
		#endregion


		/// <summary>
		///A test for Assert2xN
		///</summary>
		[TestMethod()]
		public void Assert2xNTest()
		{
			object[][] targetectArray2xN = null; // TODO: Initialize to an appropriate value
			bool expected = false; // TODO: Initialize to an appropriate value
			bool actual;
			actual = Common.Assert2xN(targetectArray2xN);
			Assert.AreEqual(expected, actual);
			Assert.Inconclusive("Verify the correctness of this test method.");
		}

		/// <summary>
		///A test for AssertNx2
		///</summary>
		[TestMethod()]
		public void AssertNx2Test()
		{
			object[][] targetectArrayNx2 = null; // TODO: Initialize to an appropriate value
			bool expected = false; // TODO: Initialize to an appropriate value
			bool actual;
			actual = Common.AssertNx2(targetectArrayNx2);
			Assert.AreEqual(expected, actual);
			Assert.Inconclusive("Verify the correctness of this test method.");
		}

		/// <summary>
		///A test for BitView
		///</summary>
		[TestMethod()]
		public void BitViewTest()
		{
			int value = 0; // TODO: Initialize to an appropriate value
			string expected = string.Empty; // TODO: Initialize to an appropriate value
			string actual;
			actual = Common.BitView(value);
			Assert.AreEqual(expected, actual);
			Assert.Inconclusive("Verify the correctness of this test method.");
		}

		/// <summary>
		///A test for Clone
		///</summary>
		[TestMethod()]
		public void CloneTest()
		{
			object source = null; // TODO: Initialize to an appropriate value
			object target = null; // TODO: Initialize to an appropriate value
			object expected = null; // TODO: Initialize to an appropriate value
			object actual;
			actual = Common.Clone(source, target);
			Assert.AreEqual(expected, actual);
			Assert.Inconclusive("Verify the correctness of this test method.");
		}

		/// <summary>
		///A test for CloneFrom
		///</summary>
		[TestMethod()]
		public void CloneFromTest()
		{
			object target = null; // TODO: Initialize to an appropriate value
			object source = null; // TODO: Initialize to an appropriate value
			object expected = null; // TODO: Initialize to an appropriate value
			object actual;
			actual = Common.CloneFrom(target, source);
			Assert.AreEqual(expected, actual);
			Assert.Inconclusive("Verify the correctness of this test method.");
		}

		/// <summary>
		///A test for CloneTo
		///</summary>
		[TestMethod()]
		public void CloneToTest()
		{
			object source = null; // TODO: Initialize to an appropriate value
			object target = null; // TODO: Initialize to an appropriate value
			object expected = null; // TODO: Initialize to an appropriate value
			object actual;
			actual = Common.CloneTo(source, target);
			Assert.AreEqual(expected, actual);
			Assert.Inconclusive("Verify the correctness of this test method.");
		}

		/// <summary>
		///A test for Convert
		///</summary>
		[TestMethod()]
		[DeploymentItem("Utils.dll")]
		public void ConvertTest()
		{
			Type type = null; // TODO: Initialize to an appropriate value
			object obj = null; // TODO: Initialize to an appropriate value
			object expected = null; // TODO: Initialize to an appropriate value
			object actual;
			actual = Common_Accessor.Convert(type, obj);
			Assert.AreEqual(expected, actual);
			Assert.Inconclusive("Verify the correctness of this test method.");
		}

		/// <summary>
		///A test for ConvertToMemberTypes
		///</summary>
		[TestMethod()]
		public void ConvertToMemberTypesTest()
		{
			MemberInfo member = null; // TODO: Initialize to an appropriate value
			object[] values = null; // TODO: Initialize to an appropriate value
			object expected = null; // TODO: Initialize to an appropriate value
			object actual;
			actual = Common.ConvertToMemberTypes(member, values);
			Assert.AreEqual(expected, actual);
			Assert.Inconclusive("Verify the correctness of this test method.");
		}

		/// <summary>
		///A test for ConvertToType
		///</summary>
		[TestMethod()]
		public void ConvertToTypeTest()
		{
			Type type = null; // TODO: Initialize to an appropriate value
			object[] values = null; // TODO: Initialize to an appropriate value
			object expected = null; // TODO: Initialize to an appropriate value
			object actual;
			actual = Common.ConvertToType(type, values);
			Assert.AreEqual(expected, actual);
			Assert.Inconclusive("Verify the correctness of this test method.");
		}

		/// <summary>
		///A test for CopyFiles
		///</summary>
		[TestMethod()]
		public void CopyFilesTest()
		{
			string src = string.Empty; // TODO: Initialize to an appropriate value
			string dst = string.Empty; // TODO: Initialize to an appropriate value
			SearchOption option = new SearchOption(); // TODO: Initialize to an appropriate value
			string[] exclusions = null; // TODO: Initialize to an appropriate value
			string[] patterns = null; // TODO: Initialize to an appropriate value
			string[] expected = null; // TODO: Initialize to an appropriate value
			string[] actual;
			actual = Common.CopyFiles(src, dst, option, exclusions, patterns);
			Assert.AreEqual(expected, actual);
			Assert.Inconclusive("Verify the correctness of this test method.");
		}

		/// <summary>
		///A test for CopyFiles
		///</summary>
		[TestMethod()]
		public void CopyFilesTest1()
		{
			string src = string.Empty; // TODO: Initialize to an appropriate value
			string dst = string.Empty; // TODO: Initialize to an appropriate value
			string rename = string.Empty; // TODO: Initialize to an appropriate value
			SearchOption option = new SearchOption(); // TODO: Initialize to an appropriate value
			double maxFileSize = 0F; // TODO: Initialize to an appropriate value
			string[] exclusions = null; // TODO: Initialize to an appropriate value
			string[] patterns = null; // TODO: Initialize to an appropriate value
			string[] expected = null; // TODO: Initialize to an appropriate value
			string[] actual;
			actual = Common.CopyFiles(src, dst, rename, option, maxFileSize, exclusions, patterns);
			Assert.AreEqual(expected, actual);
			Assert.Inconclusive("Verify the correctness of this test method.");
		}

		/// <summary>
		///A test for CopyFiles
		///</summary>
		[TestMethod()]
		public void CopyFilesTest2()
		{
			string src = string.Empty; // TODO: Initialize to an appropriate value
			string dst = string.Empty; // TODO: Initialize to an appropriate value
			string rename = string.Empty; // TODO: Initialize to an appropriate value
			SearchOption option = new SearchOption(); // TODO: Initialize to an appropriate value
			string[] patterns = null; // TODO: Initialize to an appropriate value
			string[] expected = null; // TODO: Initialize to an appropriate value
			string[] actual;
			actual = Common.CopyFiles(src, dst, rename, option, patterns);
			Assert.AreEqual(expected, actual);
			Assert.Inconclusive("Verify the correctness of this test method.");
		}

		/// <summary>
		///A test for CopyFiles
		///</summary>
		[TestMethod()]
		public void CopyFilesTest3()
		{
			string src = string.Empty; // TODO: Initialize to an appropriate value
			string dst = string.Empty; // TODO: Initialize to an appropriate value
			SearchOption option = new SearchOption(); // TODO: Initialize to an appropriate value
			string[] patterns = null; // TODO: Initialize to an appropriate value
			string[] expected = null; // TODO: Initialize to an appropriate value
			string[] actual;
			actual = Common.CopyFiles(src, dst, option, patterns);
			Assert.AreEqual(expected, actual);
			Assert.Inconclusive("Verify the correctness of this test method.");
		}

		/// <summary>
		///A test for CopyFiles
		///</summary>
		[TestMethod()]
		public void CopyFilesTest4()
		{
			string src = string.Empty; // TODO: Initialize to an appropriate value
			string dst = string.Empty; // TODO: Initialize to an appropriate value
			string rename = string.Empty; // TODO: Initialize to an appropriate value
			SearchOption option = new SearchOption(); // TODO: Initialize to an appropriate value
			double maxFileSize = 0F; // TODO: Initialize to an appropriate value
			string[] patterns = null; // TODO: Initialize to an appropriate value
			string[] expected = null; // TODO: Initialize to an appropriate value
			string[] actual;
			actual = Common.CopyFiles(src, dst, rename, option, maxFileSize, patterns);
			Assert.AreEqual(expected, actual);
			Assert.Inconclusive("Verify the correctness of this test method.");
		}

		/// <summary>
		///A test for DeleteFiles
		///</summary>
		[TestMethod()]
		public void DeleteFilesTest()
		{
			string src = string.Empty; // TODO: Initialize to an appropriate value
			SearchOption option = new SearchOption(); // TODO: Initialize to an appropriate value
			string[] patterns = null; // TODO: Initialize to an appropriate value
			string[] expected = null; // TODO: Initialize to an appropriate value
			string[] actual;
			actual = Common.DeleteFiles(src, option, patterns);
			Assert.AreEqual(expected, actual);
			Assert.Inconclusive("Verify the correctness of this test method.");
		}

		/// <summary>
		///A test for Depth
		///</summary>
		[TestMethod()]
		public void DepthTest()
		{
			Type type = null; // TODO: Initialize to an appropriate value
			int expected = 0; // TODO: Initialize to an appropriate value
			int actual;
			actual = Common.Depth(type);
			Assert.AreEqual(expected, actual);
			Assert.Inconclusive("Verify the correctness of this test method.");
		}

		/// <summary>
		///A test for EnumFromString
		///</summary>
		[TestMethod()]
		public void EnumFromStringTest()
		{
			string s = string.Empty; // TODO: Initialize to an appropriate value
			Enum expected = null; // TODO: Initialize to an appropriate value
			Enum actual;
			actual = Common.EnumFromString(s);
			Assert.AreEqual(expected, actual);
			Assert.Inconclusive("Verify the correctness of this test method.");
		}

		/// <summary>
		///A test for EnumToString
		///</summary>
		[TestMethod()]
		public void EnumToStringTest()
		{
			Enum e = null; // TODO: Initialize to an appropriate value
			string expected = string.Empty; // TODO: Initialize to an appropriate value
			string actual;
			actual = Common.EnumToString(e);
			Assert.AreEqual(expected, actual);
			Assert.Inconclusive("Verify the correctness of this test method.");
		}

		/// <summary>
		///A test for ExtractFlags
		///</summary>
		[TestMethod()]
		public void ExtractFlagsTest()
		{
			int flags = 0; // TODO: Initialize to an appropriate value
			int[] expected = null; // TODO: Initialize to an appropriate value
			int[] actual;
			actual = Common.ExtractFlags(flags);
			Assert.AreEqual(expected, actual);
			Assert.Inconclusive("Verify the correctness of this test method.");
		}

		/// <summary>
		///A test for FindFiles
		///</summary>
		[TestMethod()]
		public void FindFilesTest()
		{
			string src = string.Empty; // TODO: Initialize to an appropriate value
			SearchOption option = new SearchOption(); // TODO: Initialize to an appropriate value
			double maxFileSize = 0F; // TODO: Initialize to an appropriate value
			bool filenameOnly = false; // TODO: Initialize to an appropriate value
			string[] patterns = null; // TODO: Initialize to an appropriate value
			string[] expected = null; // TODO: Initialize to an appropriate value
			string[] actual;
			actual = Common.FindFiles(src, option, maxFileSize, filenameOnly, patterns);
			Assert.AreEqual(expected, actual);
			Assert.Inconclusive("Verify the correctness of this test method.");
		}

		/// <summary>
		///A test for FindFiles
		///</summary>
		[TestMethod()]
		public void FindFilesTest1()
		{
			string src = string.Empty; // TODO: Initialize to an appropriate value
			SearchOption option = new SearchOption(); // TODO: Initialize to an appropriate value
			string[] exclusions = null; // TODO: Initialize to an appropriate value
			bool filenameOnly = false; // TODO: Initialize to an appropriate value
			string[] patterns = null; // TODO: Initialize to an appropriate value
			string[] expected = null; // TODO: Initialize to an appropriate value
			string[] actual;
			actual = Common.FindFiles(src, option, exclusions, filenameOnly, patterns);
			Assert.AreEqual(expected, actual);
			Assert.Inconclusive("Verify the correctness of this test method.");
		}

		/// <summary>
		///A test for FindFiles
		///</summary>
		[TestMethod()]
		public void FindFilesTest2()
		{
			string src = string.Empty; // TODO: Initialize to an appropriate value
			SearchOption option = new SearchOption(); // TODO: Initialize to an appropriate value
			double maxFileSize = 0F; // TODO: Initialize to an appropriate value
			string[] exclusions = null; // TODO: Initialize to an appropriate value
			bool filenameOnly = false; // TODO: Initialize to an appropriate value
			string[] patterns = null; // TODO: Initialize to an appropriate value
			string[] expected = null; // TODO: Initialize to an appropriate value
			string[] actual;
			actual = Common.FindFiles(src, option, maxFileSize, exclusions, filenameOnly, patterns);
			Assert.AreEqual(expected, actual);
			Assert.Inconclusive("Verify the correctness of this test method.");
		}

		/// <summary>
		///A test for FindFiles
		///</summary>
		[TestMethod()]
		public void FindFilesTest3()
		{
			string src = string.Empty; // TODO: Initialize to an appropriate value
			SearchOption option = new SearchOption(); // TODO: Initialize to an appropriate value
			bool filenameOnly = false; // TODO: Initialize to an appropriate value
			string[] patterns = null; // TODO: Initialize to an appropriate value
			string[] expected = null; // TODO: Initialize to an appropriate value
			string[] actual;
			actual = Common.FindFiles(src, option, filenameOnly, patterns);
			Assert.AreEqual(expected, actual);
			Assert.Inconclusive("Verify the correctness of this test method.");
		}

		/// <summary>
		///A test for FormatDateTimeForOs
		///</summary>
		[TestMethod()]
		public void FormatDateTimeForOsTest()
		{
			DateTime dt = new DateTime(); // TODO: Initialize to an appropriate value
			string expected = string.Empty; // TODO: Initialize to an appropriate value
			string actual;
			actual = Common.FormatDateTimeForOs(dt);
			Assert.AreEqual(expected, actual);
			Assert.Inconclusive("Verify the correctness of this test method.");
		}

		/// <summary>
		///A test for GetConverter
		///</summary>
		[TestMethod()]
		public void GetConverterTest()
		{
			Type type = null; // TODO: Initialize to an appropriate value
			TypeConverter expected = null; // TODO: Initialize to an appropriate value
			TypeConverter actual;
			actual = Common.GetConverter(type);
			Assert.AreEqual(expected, actual);
			Assert.Inconclusive("Verify the correctness of this test method.");
		}

		/// <summary>
		///A test for GetEmbeddedResource
		///</summary>
		public void GetEmbeddedResourceTestHelper<TItem>()
			where TItem : class
		{
			TItem item = null; // TODO: Initialize to an appropriate value
			string resource = string.Empty; // TODO: Initialize to an appropriate value
			string expected = string.Empty; // TODO: Initialize to an appropriate value
			string actual;
			actual = Common.GetEmbeddedResource<TItem>(item, resource);
			Assert.AreEqual(expected, actual);
			Assert.Inconclusive("Verify the correctness of this test method.");
		}

		[TestMethod()]
		public void GetEmbeddedResourceTest()
		{
			GetEmbeddedResourceTestHelper<GenericParameterHelper>();
		}

		/// <summary>
		///A test for GetFields
		///</summary>
		[TestMethod()]
		public void GetFieldsTest()
		{
			object target = null; // TODO: Initialize to an appropriate value
			Func<FieldInfo, bool> predicate = null; // TODO: Initialize to an appropriate value
			FieldInfo[] expected = null; // TODO: Initialize to an appropriate value
			FieldInfo[] actual;
			actual = Common.GetFields(target, predicate);
			Assert.AreEqual(expected, actual);
			Assert.Inconclusive("Verify the correctness of this test method.");
		}

		/// <summary>
		///A test for GetFileSizeInMB
		///</summary>
		[TestMethod()]
		public void GetFileSizeInMBTest()
		{
			string filename = string.Empty; // TODO: Initialize to an appropriate value
			double expected = 0F; // TODO: Initialize to an appropriate value
			double actual;
			actual = Common.GetFileSizeInMB(filename);
			Assert.AreEqual(expected, actual);
			Assert.Inconclusive("Verify the correctness of this test method.");
		}

		/// <summary>
		///A test for GetProperties
		///</summary>
		[TestMethod()]
		public void GetPropertiesTest()
		{
			object target = null; // TODO: Initialize to an appropriate value
			Func<PropertyInfo, bool> predicate = null; // TODO: Initialize to an appropriate value
			PropertyInfo[] expected = null; // TODO: Initialize to an appropriate value
			PropertyInfo[] actual;
			actual = Common.GetProperties(target, predicate);
			Assert.AreEqual(expected, actual);
			Assert.Inconclusive("Verify the correctness of this test method.");
		}

		/// <summary>
		///A test for GetPropertyNames
		///</summary>
		[TestMethod()]
		public void GetPropertyNamesTest()
		{
			object target = null; // TODO: Initialize to an appropriate value
			Func<PropertyInfo, bool> predicate = null; // TODO: Initialize to an appropriate value
			string[] expected = null; // TODO: Initialize to an appropriate value
			string[] actual;
			actual = Common.GetPropertyNames(target, predicate);
			Assert.AreEqual(expected, actual);
			Assert.Inconclusive("Verify the correctness of this test method.");
		}

		/// <summary>
		///A test for GetPropertyValues
		///</summary>
		[TestMethod()]
		public void GetPropertyValuesTest()
		{
			object target = null; // TODO: Initialize to an appropriate value
			Func<PropertyInfo, bool> predicate = null; // TODO: Initialize to an appropriate value
			object[] expected = null; // TODO: Initialize to an appropriate value
			object[] actual;
			actual = Common.GetPropertyValues(target, predicate);
			Assert.AreEqual(expected, actual);
			Assert.Inconclusive("Verify the correctness of this test method.");
		}

		/// <summary>
		///A test for GetVariableName
		///</summary>
		public void GetVariableNameTestHelper<T>()
		{
			Expression<Func<T>> expr = null; // TODO: Initialize to an appropriate value
			string expected = string.Empty; // TODO: Initialize to an appropriate value
			string actual;
			actual = Common.GetVariableName<T>(expr);
			Assert.AreEqual(expected, actual);
			Assert.Inconclusive("Verify the correctness of this test method.");
		}

		[TestMethod()]
		public void GetVariableNameTest()
		{
			GetVariableNameTestHelper<GenericParameterHelper>();
		}

		/// <summary>
		///A test for GetWorkWeek
		///</summary>
		[TestMethod()]
		public void GetWorkWeekTest()
		{
			DateTime dt = new DateTime(); // TODO: Initialize to an appropriate value
			string expected = string.Empty; // TODO: Initialize to an appropriate value
			string actual;
			actual = Common.GetWorkWeek(dt);
			Assert.AreEqual(expected, actual);
			Assert.Inconclusive("Verify the correctness of this test method.");
		}

		/// <summary>
		///A test for InvokeGetMember
		///</summary>
		[TestMethod()]
		public void InvokeGetMemberTest()
		{
			MemberInfo member = null; // TODO: Initialize to an appropriate value
			object target = null; // TODO: Initialize to an appropriate value
			object expected = null; // TODO: Initialize to an appropriate value
			object actual;
			actual = Common.InvokeGetMember(member, target);
			Assert.AreEqual(expected, actual);
			Assert.Inconclusive("Verify the correctness of this test method.");
		}

		/// <summary>
		///A test for InvokeSetMember
		///</summary>
		[TestMethod()]
		public void InvokeSetMemberTest()
		{
			MemberInfo member = null; // TODO: Initialize to an appropriate value
			object target = null; // TODO: Initialize to an appropriate value
			object[] values = null; // TODO: Initialize to an appropriate value
			Common.InvokeSetMember(member, target, values);
			Assert.Inconclusive("A method that does not return a value cannot be verified.");
		}

		/// <summary>
		///A test for MoveFiles
		///</summary>
		[TestMethod()]
		public void MoveFilesTest()
		{
			string src = string.Empty; // TODO: Initialize to an appropriate value
			string dst = string.Empty; // TODO: Initialize to an appropriate value
			string rename = string.Empty; // TODO: Initialize to an appropriate value
			SearchOption option = new SearchOption(); // TODO: Initialize to an appropriate value
			double maxFileSize = 0F; // TODO: Initialize to an appropriate value
			string[] exclusions = null; // TODO: Initialize to an appropriate value
			string[] patterns = null; // TODO: Initialize to an appropriate value
			string[] expected = null; // TODO: Initialize to an appropriate value
			string[] actual;
			actual = Common.MoveFiles(src, dst, rename, option, maxFileSize, exclusions, patterns);
			Assert.AreEqual(expected, actual);
			Assert.Inconclusive("Verify the correctness of this test method.");
		}

		/// <summary>
		///A test for MoveFiles
		///</summary>
		[TestMethod()]
		public void MoveFilesTest1()
		{
			string src = string.Empty; // TODO: Initialize to an appropriate value
			string dst = string.Empty; // TODO: Initialize to an appropriate value
			string rename = string.Empty; // TODO: Initialize to an appropriate value
			SearchOption option = new SearchOption(); // TODO: Initialize to an appropriate value
			string[] patterns = null; // TODO: Initialize to an appropriate value
			string[] expected = null; // TODO: Initialize to an appropriate value
			string[] actual;
			actual = Common.MoveFiles(src, dst, rename, option, patterns);
			Assert.AreEqual(expected, actual);
			Assert.Inconclusive("Verify the correctness of this test method.");
		}

		/// <summary>
		///A test for MoveFiles
		///</summary>
		[TestMethod()]
		public void MoveFilesTest2()
		{
			string src = string.Empty; // TODO: Initialize to an appropriate value
			string dst = string.Empty; // TODO: Initialize to an appropriate value
			SearchOption option = new SearchOption(); // TODO: Initialize to an appropriate value
			string[] patterns = null; // TODO: Initialize to an appropriate value
			string[] expected = null; // TODO: Initialize to an appropriate value
			string[] actual;
			actual = Common.MoveFiles(src, dst, option, patterns);
			Assert.AreEqual(expected, actual);
			Assert.Inconclusive("Verify the correctness of this test method.");
		}

		/// <summary>
		///A test for MoveFiles
		///</summary>
		[TestMethod()]
		public void MoveFilesTest3()
		{
			string src = string.Empty; // TODO: Initialize to an appropriate value
			string dst = string.Empty; // TODO: Initialize to an appropriate value
			SearchOption option = new SearchOption(); // TODO: Initialize to an appropriate value
			string[] exclusions = null; // TODO: Initialize to an appropriate value
			string[] patterns = null; // TODO: Initialize to an appropriate value
			string[] expected = null; // TODO: Initialize to an appropriate value
			string[] actual;
			actual = Common.MoveFiles(src, dst, option, exclusions, patterns);
			Assert.AreEqual(expected, actual);
			Assert.Inconclusive("Verify the correctness of this test method.");
		}

		/// <summary>
		///A test for MoveFiles
		///</summary>
		[TestMethod()]
		public void MoveFilesTest4()
		{
			string src = string.Empty; // TODO: Initialize to an appropriate value
			string dst = string.Empty; // TODO: Initialize to an appropriate value
			string rename = string.Empty; // TODO: Initialize to an appropriate value
			SearchOption option = new SearchOption(); // TODO: Initialize to an appropriate value
			double maxFileSize = 0F; // TODO: Initialize to an appropriate value
			string[] patterns = null; // TODO: Initialize to an appropriate value
			string[] expected = null; // TODO: Initialize to an appropriate value
			string[] actual;
			actual = Common.MoveFiles(src, dst, rename, option, maxFileSize, patterns);
			Assert.AreEqual(expected, actual);
			Assert.Inconclusive("Verify the correctness of this test method.");
		}

		/// <summary>
		///A test for OutputKeyValuePairs
		///</summary>
		[TestMethod()]
		public void OutputKeyValuePairsTest()
		{
			object target = null; // TODO: Initialize to an appropriate value
			Func<PropertyInfo, bool> predicate = null; // TODO: Initialize to an appropriate value
			KeyValuePair<string, object>[] expected = null; // TODO: Initialize to an appropriate value
			KeyValuePair<string, object>[] actual;
			actual = Common.OutputKeyValuePairs(target, predicate);
			Assert.AreEqual(expected, actual);
			Assert.Inconclusive("Verify the correctness of this test method.");
		}

		/// <summary>
		///A test for OutputObjectArrays2xN
		///</summary>
		[TestMethod()]
		public void OutputObjectArrays2xNTest()
		{
			object target = null; // TODO: Initialize to an appropriate value
			Func<PropertyInfo, bool> predicate = null; // TODO: Initialize to an appropriate value
			object[][] expected = null; // TODO: Initialize to an appropriate value
			object[][] actual;
			actual = Common.OutputObjectArrays2xN(target, predicate);
			Assert.AreEqual(expected, actual);
			Assert.Inconclusive("Verify the correctness of this test method.");
		}

		/// <summary>
		///A test for OutputObjectArraysNx2
		///</summary>
		[TestMethod()]
		public void OutputObjectArraysNx2Test()
		{
			object target = null; // TODO: Initialize to an appropriate value
			Func<PropertyInfo, bool> predicate = null; // TODO: Initialize to an appropriate value
			object[][] expected = null; // TODO: Initialize to an appropriate value
			object[][] actual;
			actual = Common.OutputObjectArraysNx2(target, predicate);
			Assert.AreEqual(expected, actual);
			Assert.Inconclusive("Verify the correctness of this test method.");
		}

		/// <summary>
		///A test for ParseArray
		///</summary>
		public void ParseArrayTestHelper<T>()
		{
			object input = null; // TODO: Initialize to an appropriate value
			object output = null; // TODO: Initialize to an appropriate value
			object outputExpected = null; // TODO: Initialize to an appropriate value
			bool expected = false; // TODO: Initialize to an appropriate value
			bool actual;
			actual = Common.ParseArray<T>(input, ref output);
			Assert.AreEqual(outputExpected, output);
			Assert.AreEqual(expected, actual);
			Assert.Inconclusive("Verify the correctness of this test method.");
		}

		[TestMethod()]
		public void ParseArrayTest()
		{
			ParseArrayTestHelper<GenericParameterHelper>();
		}

		/// <summary>
		///A test for ParseArray
		///</summary>
		public void ParseArrayTest1Helper<K, V>()
		{
			object input = null; // TODO: Initialize to an appropriate value
			object output = null; // TODO: Initialize to an appropriate value
			object outputExpected = null; // TODO: Initialize to an appropriate value
			bool expected = false; // TODO: Initialize to an appropriate value
			bool actual;
			actual = Common.ParseArray<K, V>(input, ref output);
			Assert.AreEqual(outputExpected, output);
			Assert.AreEqual(expected, actual);
			Assert.Inconclusive("Verify the correctness of this test method.");
		}

		[TestMethod()]
		public void ParseArrayTest1()
		{
			ParseArrayTest1Helper<GenericParameterHelper, GenericParameterHelper>();
		}

		/// <summary>
		///A test for RunCommand
		///</summary>
		[TestMethod()]
		public void RunCommandTest()
		{
			string path = string.Empty; // TODO: Initialize to an appropriate value
			string args = string.Empty; // TODO: Initialize to an appropriate value
			string domain = string.Empty; // TODO: Initialize to an appropriate value
			string username = string.Empty; // TODO: Initialize to an appropriate value
			SecureString password = null; // TODO: Initialize to an appropriate value
			string expected = string.Empty; // TODO: Initialize to an appropriate value
			string actual;
			actual = Common.RunCommand(path, args, domain, username, password);
			Assert.AreEqual(expected, actual);
			Assert.Inconclusive("Verify the correctness of this test method.");
		}

		/// <summary>
		///A test for RunProcess
		///</summary>
		[TestMethod()]
		public void RunProcessTest()
		{
			string path = string.Empty; // TODO: Initialize to an appropriate value
			string args = string.Empty; // TODO: Initialize to an appropriate value
			Action<object, DataReceivedEventArgs> stdout = null; // TODO: Initialize to an appropriate value
			Action<object, DataReceivedEventArgs> stderr = null; // TODO: Initialize to an appropriate value
			int expected = 0; // TODO: Initialize to an appropriate value
			int actual;
			actual = Common.RunProcess(path, args, stdout, stderr);
			Assert.AreEqual(expected, actual);
			Assert.Inconclusive("Verify the correctness of this test method.");
		}

		/// <summary>
		///A test for StringToRegexPattern
		///</summary>
		[TestMethod()]
		public void StringToRegexPatternTest()
		{
			string str = string.Empty; // TODO: Initialize to an appropriate value
			string expected = string.Empty; // TODO: Initialize to an appropriate value
			string actual;
			actual = Common.StringToRegexPattern(str);
			Assert.AreEqual(expected, actual);
			Assert.Inconclusive("Verify the correctness of this test method.");
		}

		/// <summary>
		///A test for WildcardToRegex
		///</summary>
		[TestMethod()]
		public void WildcardToRegexTest()
		{
			string pattern = string.Empty; // TODO: Initialize to an appropriate value
			string expected = string.Empty; // TODO: Initialize to an appropriate value
			string actual;
			actual = Common.WildcardToRegex(pattern);
			Assert.AreEqual(expected, actual);
			Assert.Inconclusive("Verify the correctness of this test method.");
		}

		/// <summary>
		///A test for ZipTypesAndValues
		///</summary>
		[TestMethod()]
		public void ZipTypesAndValuesTest()
		{
			Type[] types = null; // TODO: Initialize to an appropriate value
			object[] values = null; // TODO: Initialize to an appropriate value
			object[] expected = null; // TODO: Initialize to an appropriate value
			object[] actual;
			actual = Common.ZipTypesAndValues(types, values);
			Assert.AreEqual(expected, actual);
			Assert.Inconclusive("Verify the correctness of this test method.");
		}

		/// <summary>
		///A test for ATOZ
		///</summary>
		[TestMethod()]
		public void ATOZTest()
		{
			char[] actual;
			actual = Common.ATOZ;
			Assert.Inconclusive("Verify the correctness of this test method.");
		}

		/// <summary>
		///A test for atoz
		///</summary>
		[TestMethod()]
		public void atozTest()
		{
			char[] actual;
			actual = Common.atoz;
			Assert.Inconclusive("Verify the correctness of this test method.");
		}
	}
}
